DIRECTORY.md (1)

140-141: Indentation style matches codebase convention but diverges from strict Markdown spec.

Lines 140–141 use 4 and 6 spaces respectively, consistent with all other entries in the Intervals section. However, markdownlint expects 2 and 4 spaces per MD007. Since the entire file follows the 4/6 convention, this is not a new inconsistency, but consider aligning with standard Markdown guidelines in a future refactor.

algorithms/intervals/count_non_overlapping_intervals/README.md (1)

56-60: Minor formatting and clarity improvements needed in complexity analysis.

Line 56: O(n * logn) should use consistent spacing: O(n * log n).

Line 60 states "We only initialize two extra variables" but doesn't explicitly complete the notation. Suggest: "O(1) where we only initialize two extra variables..." for clarity and consistency with the Time Complexity section format.

algorithms/intervals/count_non_overlapping_intervals/__init__.py (2)

4-23: Consider adding input validation for interval structure.

The function assumes each interval contains exactly two elements [start, end] and that start <= end. Invalid inputs like [[1]], [[1, 2, 3]], or [[5, 1]] could cause IndexError or produce incorrect results.

Consider adding validation at the start of the function:

🔎 Suggested input validation

 def count_min_non_overlapping_intervals(intervals: List[List[int]]) -> int:
     """
     Counts the minimum number of intervals that must be removed to make the intervals non-overlapping. Modifies the
     input list in place
     Args:
         intervals (List[List[int]]): The intervals to check
     Returns:
         int: number of intervals to remove
     """
     if not intervals:
         return 0
+    # Validate interval structure
+    for interval in intervals:
+        if len(interval) != 2:
+            raise ValueError(f"Each interval must have exactly 2 elements, got {len(interval)}")
+        if interval[0] > interval[1]:
+            raise ValueError(f"Interval start must be <= end, got {interval}")
     intervals.sort(key=lambda x: x[1])
     end = intervals[0][1]
     count = 1
     for i in range(1, len(intervals)):
         # Non-overlapping interval found
         if intervals[i][0] >= end:
             end = intervals[i][1]
             count += 1
     return len(intervals) - count

---

26-50: Consider adding input validation for interval structure.

Similar to the first implementation, this function assumes well-formed intervals. Apply the same validation logic to ensure robustness.

🔎 Suggested input validation

 def count_min_non_overlapping_intervals_2(intervals: List[List[int]]) -> int:
     """
     Counts the minimum number of intervals that must be removed to make the intervals non-overlapping. Does not modify
      the input list in place, this instead uses a sorted copy of the input intervals
     Args:
         intervals (List[List[int]]): The intervals to check
     Returns:
         int: number of intervals to remove
     """
     if not intervals:
         return 0
+    # Validate interval structure
+    for interval in intervals:
+        if len(interval) != 2:
+            raise ValueError(f"Each interval must have exactly 2 elements, got {len(interval)}")
+        if interval[0] > interval[1]:
+            raise ValueError(f"Interval start must be <= end, got {interval}")

     sorted_intervals = sorted(intervals, key=lambda x: x[1])

     end = sorted_intervals[0][1]
     count = 1

     for current_interval in sorted_intervals[1:]:
         current_interval_start, current_interval_end = current_interval
         # Non-overlapping interval found
         if current_interval_start >= end:
             end = current_interval_end
             count += 1

     return len(sorted_intervals) - count

algorithms/intervals/count_non_overlapping_intervals/test_count_min_non_overlapping_intervals.py (1)

10-19: Consider adding edge case test coverage.

The test cases cover various overlapping scenarios well, but could benefit from additional edge cases:

• Single interval: [[1, 5]] → expected 0
• Empty list: [] → expected 0 (implementation handles this)
• Negative intervals: [[-5, -1], [-3, 0], [1, 3]]
• Large gaps: [[1, 2], [100, 200]] → expected 0

🔎 Suggested additional test cases

 COUNT_NON_OVERLAPPING_INTERVALS_TEST_CASES = [
     ([[1, 3], [5, 8], [4, 10], [11, 13]], 1),
     ([[1, 2], [2, 3], [3, 4], [1, 3]], 1),
     ([[1, 2], [1, 2], [1, 2]], 2),
     ([[1, 2], [2, 3]], 0),
     ([[1, 5], [2, 3], [3, 4], [4, 6]], 1),
     ([[1, 3], [3, 5], [4, 6], [5, 7]], 1),
     ([[1, 3], [2, 4], [3, 5]], 1),
     ([[0, 2], [1, 3], [2, 4], [3, 5], [4, 6]], 2),
+    # Edge cases
+    ([[1, 5]], 0),  # Single interval
+    ([], 0),  # Empty list
+    ([[-5, -1], [-3, 0], [1, 3]], 1),  # Negative intervals
+    ([[1, 2], [100, 200]], 0),  # Large gaps
 ]

Configuration used: defaults

Review profile: CHILL

Plan: Pro